ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೆಂಪೊರಲ್ APIಯ ಡ್ಯುರೇಶನ್ನ ಶಕ್ತಿಯನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಿ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ ಸಮಯದ ಅಂತರದ ಗಣಿತವನ್ನು ವಿವರಿಸುತ್ತದೆ, ಜಾಗತಿಕ ಡೆವಲಪರ್ಗಳಿಗೆ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕ ಒಳನೋಟಗಳನ್ನು ನೀಡುತ್ತದೆ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೆಂಪೊರಲ್ ಡ್ಯುರೇಶನ್ ಅರಿತ್ಮೆಟಿಕ್ನಲ್ಲಿ ಪ್ರಾವೀಣ್ಯತೆ: ಸಮಯದ ಅಂತರದ ಗಣಿತಕ್ಕೆ ಒಂದು ಜಾಗತಿಕ ಮಾರ್ಗದರ್ಶಿ
ವೆಬ್ ಅಭಿವೃದ್ಧಿಯ ನಿರಂತರವಾಗಿ ವಿಕಸಿಸುತ್ತಿರುವ ಕ್ಷೇತ್ರದಲ್ಲಿ, ಸಮಯವನ್ನು ನಿಖರವಾಗಿ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿ ನಿರ್ವಹಿಸುವುದು ಅತ್ಯಗತ್ಯ. ನೀವು ಬೇರೆ ಬೇರೆ ಟೈಮ್ಝೋನ್ಗಳಲ್ಲಿ ಪ್ರಾಜೆಕ್ಟ್ನ ಅಂತಿಮ ಗಡುವುಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತಿರಲಿ, ಚಂದಾದಾರಿಕೆ ನವೀಕರಣಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತಿರಲಿ, ಅಥವಾ ಜಾಗತಿಕವಾಗಿ ಈವೆಂಟ್ಗಳನ್ನು ನಿಗದಿಪಡಿಸುತ್ತಿರಲಿ, ನಿಖರವಾದ ಸಮಯದ ಅಂತರದ ಗಣಿತವು ಅತ್ಯಗತ್ಯ. ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ಒಂದು ಶಕ್ತಿಯುತ ಸಾಧನವನ್ನು ಪರಿಚಯಿಸಿದೆ: ಟೆಂಪೊರಲ್ API, ಮತ್ತು ನಿರ್ದಿಷ್ಟವಾಗಿ, ಅದರ ಡ್ಯುರೇಶನ್ ಆಬ್ಜೆಕ್ಟ್. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೆಂಪೊರಲ್ ಡ್ಯುರೇಶನ್ ಅರಿತ್ಮೆಟಿಕ್ ಅನ್ನು ಸರಳೀಕರಿಸುತ್ತದೆ, ಅದರ ಸಾಮರ್ಥ್ಯಗಳು ಮತ್ತು ಪ್ರಾಯೋಗಿಕ ಅನ್ವಯಗಳ ಬಗ್ಗೆ ಜಾಗತಿಕ ದೃಷ್ಟಿಕೋನವನ್ನು ಒದಗಿಸುತ್ತದೆ.
ದೃಢವಾದ ಸಮಯ ನಿರ್ವಹಣೆಯ ಅವಶ್ಯಕತೆ
ಐತಿಹಾಸಿಕವಾಗಿ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನ ಅಂತರ್ನಿರ್ಮಿತ Date ಆಬ್ಜೆಕ್ಟ್ ಡೆವಲಪರ್ಗಳಿಗೆ ನಿರಾಶೆಯ ಮೂಲವಾಗಿದೆ. ಅದರ ಅಸಂಗತತೆಗಳು, ಬದಲಾಯಿಸಲಾಗದ (immutability) ಗುಣದ ಕೊರತೆ, ಮತ್ತು ಟೈಮ್ಝೋನ್ಗಳು ಮತ್ತು ಹಗಲು ಉಳಿತಾಯ ಸಮಯದ (daylight saving time) ಸಂಕೀರ್ಣ ನಿರ್ವಹಣೆಯು ಹಲವಾರು ದೋಷಗಳಿಗೆ ಮತ್ತು ಬಾಹ್ಯ ಲೈಬ್ರರಿಗಳ ನಿರಂತರ ಅವಶ್ಯಕತೆಗೆ ಕಾರಣವಾಗಿದೆ. ECMAScript ಗಾಗಿ ಪ್ರಸ್ತಾಪಿತ ಮಾನದಂಡವಾದ ಟೆಂಪೊರಲ್ API, ದಿನಾಂಕಗಳು, ಸಮಯಗಳು ಮತ್ತು ಅವಧಿಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಹೆಚ್ಚು ಅರ್ಥಗರ್ಭಿತ, ಸ್ಥಿರ ಮತ್ತು ಶಕ್ತಿಯುತವಾದ ಮಾರ್ಗವನ್ನು ನೀಡುವ ಮೂಲಕ ಈ ಸಮಸ್ಯೆಗಳನ್ನು ಸರಿಪಡಿಸುವ ಗುರಿಯನ್ನು ಹೊಂದಿದೆ.
ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗೆ, ಸವಾಲುಗಳು ಇನ್ನಷ್ಟು ಹೆಚ್ಚಾಗುತ್ತವೆ. ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ:
- ಬರ್ಲಿನ್ನಲ್ಲಿರುವ ಒಬ್ಬ ಪ್ರಾಜೆಕ್ಟ್ ಮ್ಯಾನೇಜರ್ ಟೋಕಿಯೊಗೆ ಒಂದು ಸರಕು ತಲುಪುವ ಸಮಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು, ಟೈಮ್ಝೋನ್ ವ್ಯತ್ಯಾಸಗಳು ಮತ್ತು ಸಂಭಾವ್ಯ ವಿಳಂಬಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳುವುದು.
- ನ್ಯೂಯಾರ್ಕ್ನಲ್ಲಿರುವ ಒಬ್ಬ ಹಣಕಾಸು ವಿಶ್ಲೇಷಕ ಯುರೋಪಿನಾದ್ಯಂತ ವಿವಿಧ ಹಣಕಾಸು ತ್ರೈಮಾಸಿಕಗಳಲ್ಲಿ ಮಾಡಿದ ಎರಡು ಬಡ್ಡಿ ಪಾವತಿಗಳ ನಡುವಿನ ನಿಖರವಾದ ಅವಧಿಯನ್ನು ನಿರ್ಧರಿಸುವುದು.
- ಸಿಂಗಾಪುರದಲ್ಲಿರುವ ಒಂದು ಮಾರ್ಕೆಟಿಂಗ್ ತಂಡವು ಜಾಗತಿಕ ಪ್ರಚಾರವನ್ನು ಪ್ರಾರಂಭಿಸಲು ವೇಳಾಪಟ್ಟಿ ಮಾಡುವುದು, ಅದು ಉತ್ತರ ಅಮೇರಿಕಾ, ಯುರೋಪ್ ಮತ್ತು ಏಷ್ಯಾದಲ್ಲಿ ಪ್ರಮುಖ ವೀಕ್ಷಣಾ ಸಮಯಗಳೊಂದಿಗೆ ಹೊಂದಿಕೆಯಾಗುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು.
ಈ ಸನ್ನಿವೇಶಗಳು ಸಮಯದ ಅಂತರದ ಗಣಿತಕ್ಕೆ ಒಂದು ಪ್ರಮಾಣಿತ, ಅಸ್ಪಷ್ಟವಲ್ಲದ ವಿಧಾನದ ನಿರ್ಣಾಯಕ ಅಗತ್ಯವನ್ನು ಎತ್ತಿ ತೋರಿಸುತ್ತವೆ. ಟೆಂಪೊರಲ್ APIಯ Duration ಆಬ್ಜೆಕ್ಟ್ ಈ ಅಗತ್ಯವನ್ನು ನೇರವಾಗಿ ಪೂರೈಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೆಂಪೊರಲ್ ಡ್ಯುರೇಶನ್ ಆಬ್ಜೆಕ್ಟ್ನ ಪರಿಚಯ
Temporal.Duration ಆಬ್ಜೆಕ್ಟ್ ಯಾವುದೇ ನಿರ್ದಿಷ್ಟ ಸಮಯದ ಬಿಂದುವಿನಿಂದ ಸ್ವತಂತ್ರವಾಗಿ ಸಮಯದ ಪ್ರಮಾಣವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಇದು '2 ವರ್ಷಗಳು, 3 ತಿಂಗಳುಗಳು, ಮತ್ತು 4 ದಿನಗಳು' ನಂತಹ ಕಳೆದ ಸಮಯದ ಅಳತೆಯಾಗಿದೆ. ಅವಧಿಗಳನ್ನು ಸಮಯದ ಬಿಂದುಗಳೊಂದಿಗೆ ಗೊಂದಲಗೊಳಿಸುತ್ತಿದ್ದ ಹಿಂದಿನ ವಿಧಾನಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿ, Temporal.Duration ಕೇವಲ ಸಮಯದ ಪರಿಮಾಣದ ಮೇಲೆ ಗಮನಹರಿಸುತ್ತದೆ. ಈ ಪ್ರತ್ಯೇಕತೆಯು ಅದರ ಶಕ್ತಿ ಮತ್ತು ಸರಳತೆಗೆ ಪ್ರಮುಖವಾಗಿದೆ.
ಡ್ಯುರೇಶನ್ನ ಪ್ರಮುಖ ಘಟಕಗಳು
ಒಂದು Temporal.Duration ಆಬ್ಜೆಕ್ಟ್ ವಿವಿಧ ಘಟಕಗಳಲ್ಲಿ ಸಮಯವನ್ನು ಪ್ರತಿನಿಧಿಸಬಹುದು. ಅದು ಬೆಂಬಲಿಸುವ ಪ್ರಾಥಮಿಕ ಘಟಕಗಳು:
- ವರ್ಷಗಳು (
years) - ತಿಂಗಳುಗಳು (
months) - ವಾರಗಳು (
weeks) - ದಿನಗಳು (
days) - ಗಂಟೆಗಳು (
hours) - ನಿಮಿಷಗಳು (
minutes) - ಸೆಕೆಂಡುಗಳು (
seconds) - ಮಿಲಿಸೆಕೆಂಡುಗಳು (
milliseconds) - ಮೈಕ್ರೋಸೆಕೆಂಡುಗಳು (
microseconds) - ನ್ಯಾನೋಸೆಕೆಂಡುಗಳು (
nanoseconds)
ಒಂದು Duration ಆಬ್ಜೆಕ್ಟ್ ಧನಾತ್ಮಕ (ಸಮಯದ ಮುನ್ನಡೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ) ಅಥವಾ ಋಣಾತ್ಮಕ (ಹಿಂದಿನ ಚಲನೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ) ಆಗಿರಬಹುದು. Temporal.Duration ಬದಲಾಯಿಸಲಾಗದ (immutable) ಗುಣವನ್ನು ಹೊಂದಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸುವುದು ಮುಖ್ಯ. ಒಮ್ಮೆ ರಚಿಸಿದ ನಂತರ, ಅದರ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ. ಅವಧಿಯನ್ನು ಮಾರ್ಪಡಿಸುವಂತೆ ತೋರುವ ಯಾವುದೇ ಕಾರ್ಯಾಚರಣೆಯು ವಾಸ್ತವವಾಗಿ ಹೊಸ Duration ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
ಟೆಂಪೊರಲ್ ಡ್ಯುರೇಶನ್ಗಳನ್ನು ರಚಿಸುವುದು
ನೀವು Temporal.Duration ಆಬ್ಜೆಕ್ಟ್ಗಳನ್ನು ಹಲವು ರೀತಿಗಳಲ್ಲಿ ರಚಿಸಬಹುದು, ಪ್ರತಿಯೊಂದೂ ವಿಭಿನ್ನ ಸನ್ನಿವೇಶಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ.
1. Temporal.Duration.from() ಮೆಥಡ್ ಬಳಸುವುದು
ಇದು ಅತ್ಯಂತ ಬಹುಮುಖ ವಿಧಾನವಾಗಿದೆ, ಇದು ಆಬ್ಜೆಕ್ಟ್ ಲಿಟರಲ್ ಅಥವಾ ISO 8601 ಡ್ಯುರೇಶನ್ ಸ್ಟ್ರಿಂಗ್ ಸೇರಿದಂತೆ ವಿವಿಧ ಇನ್ಪುಟ್ಗಳಿಂದ ಡ್ಯುರೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಆಬ್ಜೆಕ್ಟ್ ಲಿಟರಲ್ನಿಂದ:
ನೀವು ಸೇರಿಸಲು ಬಯಸುವ ಘಟಕಗಳನ್ನು ಆಬ್ಜೆಕ್ಟ್ನ ಪ್ರಾಪರ್ಟಿಗಳಾಗಿ ಒದಗಿಸಿ.
const twoYearsThreeMonths = Temporal.Duration.from({
years: 2,
months: 3
});
console.log(twoYearsThreeMonths);
// Temporal.Duration { years: 2, months: 3, ... }
const oneDayEightHours = Temporal.Duration.from({
days: 1,
hours: 8,
minutes: 30
});
console.log(oneDayEightHours);
// Temporal.Duration { days: 1, hours: 8, minutes: 30, ... }
const negativeDuration = Temporal.Duration.from({
hours: -5,
minutes: -15
});
console.log(negativeDuration);
// Temporal.Duration { hours: -5, minutes: -15, ... }
ISO 8601 ಡ್ಯುರೇಶನ್ ಸ್ಟ್ರಿಂಗ್ನಿಂದ:
ISO 8601 ಮಾನದಂಡವು ಡ್ಯುರೇಶನ್ಗಳಿಗಾಗಿ ಒಂದು ಸಂಕ್ಷಿಪ್ತ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದರ ಫಾರ್ಮ್ಯಾಟ್ PnYnMnDTnHnMnS ಆಗಿದೆ, ಇಲ್ಲಿ:
Pಡ್ಯುರೇಶನ್ನ ಪ್ರಾರಂಭವನ್ನು ಸೂಚಿಸುತ್ತದೆ.Yವರ್ಷಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.Mತಿಂಗಳುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.Dದಿನಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.Tದಿನಾಂಕದ ಘಟಕಗಳನ್ನು ಸಮಯದ ಘಟಕಗಳಿಂದ ಪ್ರತ್ಯೇಕಿಸುತ್ತದೆ.Hಗಂಟೆಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.Mನಿಮಿಷಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.Sಸೆಕೆಂಡುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
'T' ನಂತರದ 'M' ನಿಮಿಷಗಳನ್ನು ಸೂಚಿಸಿದರೆ, 'T' ಗಿಂತ ಹಿಂದಿನ 'M' ತಿಂಗಳುಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಸಮಯದ ಘಟಕಗಳು (ಗಂಟೆಗಳು, ನಿಮಿಷಗಳು, ಸೆಕೆಂಡುಗಳು) ಐಚ್ಛಿಕವಾಗಿವೆ ಮತ್ತು ಶೂನ್ಯವಲ್ಲದ ಮೌಲ್ಯವಿದ್ದಾಗ ಮಾತ್ರ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ.
const isoDuration1 = Temporal.Duration.from('P1Y2M3DT4H5M6S');
console.log(isoDuration1);
// Temporal.Duration { years: 1, months: 2, days: 3, hours: 4, minutes: 5, seconds: 6, ... }
const isoDuration2 = Temporal.Duration.from('P10DT5H'); // 10 days, 5 hours
console.log(isoDuration2);
// Temporal.Duration { days: 10, hours: 5, ... }
const isoDuration3 = Temporal.Duration.from('P3M'); // 3 months
console.log(isoDuration3);
// Temporal.Duration { months: 3, ... }
// Invalid ISO 8601 strings will throw an error.
// Temporal.Duration.from('PT10M5S'); // This is valid
// Temporal.Duration.from('10M'); // This is not valid without 'P'
2. Temporal.Duration() ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಬಳಸುವುದು
ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ನೇರ ಇನ್ಸ್ಟಾನ್ಶಿಯೇಶನ್ಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ ಸಾಮಾನ್ಯವಾಗಿ from() ಅನ್ನು ಬಳಸಲು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಇದು ಅಮಾನ್ಯ ಇನ್ಪುಟ್ಗಳಿಗೆ ಹೆಚ್ಚು ನಮ್ಯತೆ ಮತ್ತು ಉತ್ತಮ ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ನೀಡುತ್ತದೆ.
const constructorDuration = new Temporal.Duration(0, 0, 0, 1, 2, 3); // years, months, weeks, days, hours, minutes
console.log(constructorDuration);
// Temporal.Duration { years: 0, months: 0, weeks: 0, days: 1, hours: 2, minutes: 3, ... }
// Note: The constructor takes arguments in a fixed order (years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds).
// Providing fewer arguments means later units are treated as zero.
const partialDuration = new Temporal.Duration(1, 6); // 1 year, 6 months
console.log(partialDuration);
// Temporal.Duration { years: 1, months: 6, ... }
ಡ್ಯುರೇಶನ್ ಘಟಕಗಳನ್ನು ಪ್ರವೇಶಿಸುವುದು
ಒಮ್ಮೆ ನೀವು Temporal.Duration ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹೊಂದಿದ ನಂತರ, ಅದರ ಪ್ರತ್ಯೇಕ ಘಟಕಗಳನ್ನು ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಬಳಸಿ ಪ್ರವೇಶಿಸಬಹುದು:
const myDuration = Temporal.Duration.from({
years: 5,
days: 10,
hours: 12,
minutes: 45
});
console.log(myDuration.years);
// 5
console.log(myDuration.days);
// 10
console.log(myDuration.hours);
// 12
console.log(myDuration.minutes);
// 45
console.log(myDuration.seconds); // Units not specified are 0
// 0
ಟೆಂಪೊರಲ್ ಡ್ಯುರೇಶನ್ ಅರಿತ್ಮೆಟಿಕ್: ಪ್ರಮುಖ ಕಾರ್ಯಾಚರಣೆಗಳು
Temporal.Duration ಆಬ್ಜೆಕ್ಟ್ನ ನಿಜವಾದ ಶಕ್ತಿಯು ಅದರ ಅಂಕಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿದೆ. ಈ ಕಾರ್ಯಾಚರಣೆಗಳು ನಿಮಗೆ ಅವಧಿಗಳನ್ನು ಸೇರಿಸಲು, ಕಳೆಯಲು, ಗುಣಿಸಲು ಮತ್ತು ಭಾಗಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ, ಸಮಯದ ಅಂತರಗಳ ಮೇಲೆ ನಿಖರವಾದ ನಿಯಂತ್ರಣವನ್ನು ಒದಗಿಸುತ್ತವೆ.
1. ಡ್ಯುರೇಶನ್ಗಳನ್ನು ಸೇರಿಸುವುದು (add())
add() ಮೆಥಡ್ ಎರಡು Temporal.Duration ಆಬ್ಜೆಕ್ಟ್ಗಳನ್ನು ಸಂಯೋಜಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಡ್ಯುರೇಶನ್ಗಳನ್ನು ಸೇರಿಸುವಾಗ, ಘಟಕಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, '1 ವರ್ಷ' ಮತ್ತು '2 ತಿಂಗಳುಗಳನ್ನು' ಸೇರಿಸಿದರೆ '1 ವರ್ಷ, 2 ತಿಂಗಳುಗಳ' ಅವಧಿಯಾಗುತ್ತದೆ.
const duration1 = Temporal.Duration.from({ days: 10, hours: 5 });
const duration2 = Temporal.Duration.from({ days: 5, hours: 10 });
const totalDuration = duration1.add(duration2);
console.log(totalDuration);
// Temporal.Duration { days: 15, hours: 15, ... }
const duration3 = Temporal.Duration.from({ years: 1, months: 6 });
const duration4 = Temporal.Duration.from({ months: 8, days: 15 });
const combinedDuration = duration3.add(duration4);
console.log(combinedDuration);
// Temporal.Duration { years: 1, months: 14, days: 15, ... }
// Note: This is a simple aggregation. Temporal will handle unit rollovers (e.g., 14 months becoming 1 year and 2 months) when interacting with PlainDate/Time objects.
// Adding a negative duration is equivalent to subtraction
const duration5 = Temporal.Duration.from({ hours: 3 });
const duration6 = Temporal.Duration.from({ hours: -1 });
const result = duration5.add(duration6);
console.log(result);
// Temporal.Duration { hours: 2, ... }
2. ಡ್ಯುರೇಶನ್ಗಳನ್ನು ಕಳೆಯುವುದು (subtract())
subtract() ಮೆಥಡ್ add() ನಂತೆಯೇ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಆದರೆ ವ್ಯವಕಲನವನ್ನು ಮಾಡುತ್ತದೆ.
const durationA = Temporal.Duration.from({ days: 20, hours: 10 });
const durationB = Temporal.Duration.from({ days: 5, hours: 3 });
const remainingDuration = durationA.subtract(durationB);
console.log(remainingDuration);
// Temporal.Duration { days: 15, hours: 7, ... }
// Subtracting a duration that results in a negative value
const durationC = Temporal.Duration.from({ minutes: 30 });
const durationD = Temporal.Duration.from({ minutes: 45 });
const negativeResult = durationC.subtract(durationD);
console.log(negativeResult);
// Temporal.Duration { minutes: -15, ... }
3. ಡ್ಯುರೇಶನ್ ಅನ್ನು ನಿರಾಕರಿಸುವುದು (negated())
negated() ಮೆಥಡ್ ಹೊಸ Duration ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಅದರ ಎಲ್ಲಾ ಘಟಕಗಳನ್ನು ತಿರುಗುಮುರುಗಾಗಿ (ಧನಾತ್ಮಕವು ಋಣಾತ್ಮಕವಾಗುತ್ತದೆ, ಮತ್ತು ಋಣಾತ್ಮಕವು ಧನಾತ್ಮಕವಾಗುತ್ತದೆ) ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
const positiveDuration = Temporal.Duration.from({ hours: 10, minutes: 30 });
const negativeDuration = positiveDuration.negated();
console.log(negativeDuration);
// Temporal.Duration { hours: -10, minutes: -30, ... }
const alreadyNegative = Temporal.Duration.from({ days: -5 });
const nowPositive = alreadyNegative.negated();
console.log(nowPositive);
// Temporal.Duration { days: 5, ... }
4. ಡ್ಯುರೇಶನ್ನ ಸಂಪೂರ್ಣ ಮೌಲ್ಯ (abs())
abs() ಮೆಥಡ್ ಹೊಸ Duration ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಅದರ ಎಲ್ಲಾ ಘಟಕಗಳನ್ನು ಋಣಾತ್ಮಕವಲ್ಲದಂತೆ ಮಾಡಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಸಮಯದ ಅಂತರದ ದಿಕ್ಕನ್ನು ಲೆಕ್ಕಿಸದೆ ಅದರ ಪರಿಮಾಣದ ಬಗ್ಗೆ ಮಾತ್ರ ನೀವು ಕಾಳಜಿ ವಹಿಸಿದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.
const negativeDuration = Temporal.Duration.from({ hours: -8, minutes: -20 });
const absoluteDuration = negativeDuration.abs();
console.log(absoluteDuration);
// Temporal.Duration { hours: 8, minutes: 20, ... }
5. ಡ್ಯುರೇಶನ್ಗಳನ್ನು ಗುಣಿಸುವುದು (multiply())
multiply() ಮೆಥಡ್ ನಿಮಗೆ ಒಂದು ಡ್ಯುರೇಶನ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯಿಂದ ಅಳೆಯಲು ಅನುಮತಿಸುತ್ತದೆ. ಪುನರಾವರ್ತಿತ ಈವೆಂಟ್ಗಳ ಒಟ್ಟು ಸಮಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು ಅಥವಾ ಮೂಲ ಅಂತರದ ಆಧಾರದ ಮೇಲೆ ಭವಿಷ್ಯದ ಮೈಲಿಗಲ್ಲುಗಳನ್ನು ನಿರ್ಧರಿಸುವಂತಹ ಕಾರ್ಯಗಳಿಗೆ ಇದು ಅತ್ಯಂತ ಉಪಯುಕ್ತವಾಗಿದೆ.
const dailyDuration = Temporal.Duration.from({ days: 1 });
const twoWeeks = dailyDuration.multiply(14);
console.log(twoWeeks);
// Temporal.Duration { days: 14, ... }
const hourlyIncrement = Temporal.Duration.from({ hours: 1 });
const workWeek = hourlyIncrement.multiply(40);
console.log(workWeek);
// Temporal.Duration { hours: 40, ... }
const projectPhase = Temporal.Duration.from({ months: 2 });
const fullProject = projectPhase.multiply(3);
console.log(fullProject);
// Temporal.Duration { months: 6, ... }
// Multiplication can also be done with negative numbers
const futureEvent = Temporal.Duration.from({ days: 5 }).multiply(-2);
console.log(futureEvent);
// Temporal.Duration { days: -10, ... }
6. ಡ್ಯುರೇಶನ್ಗಳನ್ನು ಭಾಗಿಸುವುದು (divide())
divide() ಮೆಥಡ್ ನಿಮಗೆ ಒಂದು ಡ್ಯುರೇಶನ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯಿಂದ ಭಾಗಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಒಂದು ಈವೆಂಟ್ನ ಸರಾಸರಿ ಅವಧಿಯನ್ನು ನಿರ್ಧರಿಸುವುದು ಅಥವಾ ಒಟ್ಟು ಸಮಯವನ್ನು ಸಣ್ಣ, ಸಮಾನ ಭಾಗಗಳಾಗಿ ವಿಭಜಿಸುವಂತಹ ಕಾರ್ಯಗಳಿಗೆ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.
ಭಾಗಾಕಾರದ ಬಗ್ಗೆ ಪ್ರಮುಖ ಸೂಚನೆ: ಟೆಂಪೊರಲ್ Duration ನಲ್ಲಿ ಭಾಗಾಕಾರವನ್ನು ಪ್ರತಿ ಘಟಕಕ್ಕೆ ಪೂರ್ಣಾಂಕ ಸಂಖ್ಯೆಯ ಘಟಕಗಳನ್ನು ಹಿಂತಿರುಗಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಯಾವುದೇ ಭಾಗಶಃ ಭಾಗವನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಕತ್ತರಿಸಲಾಗುತ್ತದೆ (floored). ಭಾಗಶಃ ಫಲಿತಾಂಶಗಳ ಅಗತ್ಯವಿರುವ ಸನ್ನಿವೇಶಗಳಿಗಾಗಿ, ನೀವು ಸಾಮಾನ್ಯವಾಗಿ PlainDateTime ಅಥವಾ Instant ಆಬ್ಜೆಕ್ಟ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿ ನಂತರ ಪರಿಣಾಮವಾಗಿ ಬರುವ ಡ್ಯುರೇಶನ್ ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತೀರಿ.
const totalWorkTime = Temporal.Duration.from({ hours: 40, minutes: 30 });
const timePerTask = totalWorkTime.divide(5);
console.log(timePerTask);
// Temporal.Duration { hours: 8, minutes: 1, ... } // 40.5 hours / 5 = 8.1 hours. The 0.1 hours (6 minutes) is truncated.
const projectDuration = Temporal.Duration.from({ days: 90 });
const phaseDuration = projectDuration.divide(3);
console.log(phaseDuration);
// Temporal.Duration { days: 30, ... }
// Dividing by a negative number
const longDuration = Temporal.Duration.from({ years: 2 }).divide(-4);
console.log(longDuration);
// Temporal.Duration { years: -0, ... } // -0.5 years results in 0 years due to truncation.
// For more precise calculations involving division and fractional parts, consider using methods that operate on Temporal.Instant or Temporal.PlainDateTime.
7. ಡ್ಯುರೇಶನ್ಗಳನ್ನು ದುಂಡಗಾಗಿಸುವುದು (round())
round() ಮೆಥಡ್ ಡ್ಯುರೇಶನ್ಗಳನ್ನು ಸಾಮಾನ್ಯಗೊಳಿಸಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ವಿಭಿನ್ನ ಘಟಕಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಅಥವಾ ನೀವು ನಿರ್ದಿಷ್ಟ ಘಟಕದಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ನಿಖರತೆಯೊಂದಿಗೆ ಡ್ಯುರೇಶನ್ ಅನ್ನು ವ್ಯಕ್ತಪಡಿಸಬೇಕಾದಾಗ. ಇದು ಒಂದು ಘಟಕ ಮತ್ತು ಒಂದು ರೌಂಡಿಂಗ್ ಮೋಡ್ ಅನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
ಸಾಮಾನ್ಯ ರೌಂಡಿಂಗ್ ಮೋಡ್ಗಳು ಸೇರಿವೆ:
Temporal.RoundingMode.trunc: ಶೂನ್ಯದ ಕಡೆಗೆ ಕತ್ತರಿಸುತ್ತದೆ.Temporal.RoundingMode.floor: ಕೆಳಗೆ ದುಂಡಗಾಗಿಸುತ್ತದೆ.Temporal.RoundingMode.ceil: ಮೇಲೆ ದುಂಡಗಾಗಿಸುತ್ತದೆ.Temporal.RoundingMode.halfExpand: ಧನಾತ್ಮಕ ಅನಂತತೆಯ ಕಡೆಗೆ ದುಂಡಗಾಗಿಸುತ್ತದೆ, ಅರ್ಧಗಳನ್ನು ಶೂನ್ಯದಿಂದ ದೂರಕ್ಕೆ ದುಂಡಗಾಗಿಸುತ್ತದೆ.
const impreciseDuration = Temporal.Duration.from({
hours: 2,
minutes: 35,
seconds: 45
});
// Round to the nearest minute, using halfExpand (standard rounding)
const roundedToMinute = impreciseDuration.round('minute', Temporal.RoundingMode.halfExpand);
console.log(roundedToMinute);
// Temporal.Duration { hours: 2, minutes: 36, ... } // 35 minutes and 45 seconds rounds up to 36 minutes
// Truncate to the nearest hour
const truncatedToHour = impreciseDuration.round('hour', Temporal.RoundingMode.trunc);
console.log(truncatedToHour);
// Temporal.Duration { hours: 2, ... } // Discards the minutes and seconds.
// Round up to the nearest hour
const ceiledToHour = impreciseDuration.round('hour', Temporal.RoundingMode.ceil);
console.log(ceiledToHour);
// Temporal.Duration { hours: 3, ... } // Since there are minutes and seconds, it rounds up.
// Rounding to a smaller unit (e.g., to seconds) can reveal more precision
const preciseRounding = impreciseDuration.round('second', Temporal.RoundingMode.halfExpand);
console.log(preciseRounding);
// Temporal.Duration { hours: 2, minutes: 35, seconds: 45, ... }
8. ಡ್ಯುರೇಶನ್ಗಳನ್ನು ಹೋಲಿಸುವುದು (compare())
ಸ್ಟ್ಯಾಟಿಕ್ Temporal.Duration.compare() ಮೆಥಡ್ ಎರಡು Duration ಆಬ್ಜೆಕ್ಟ್ಗಳನ್ನು ಹೋಲಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಇದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ:
1ಮೊದಲ ಡ್ಯುರೇಶನ್ ಎರಡನೆಯದಕ್ಕಿಂತ ದೊಡ್ಡದಾಗಿದ್ದರೆ.-1ಮೊದಲ ಡ್ಯುರೇಶನ್ ಎರಡನೆಯದಕ್ಕಿಂತ ಚಿಕ್ಕದಾಗಿದ್ದರೆ.0ಡ್ಯುರೇಶನ್ಗಳು ಸಮಾನವಾಗಿದ್ದರೆ.
ಹೋಲಿಕೆಯನ್ನು ಎರಡೂ ಡ್ಯುರೇಶನ್ಗಳನ್ನು ಒಂದು ಸಾಮಾನ್ಯ ಚಿಕ್ಕ ಘಟಕಕ್ಕೆ (ನ್ಯಾನೋಸೆಕೆಂಡುಗಳು) ಪರಿವರ್ತಿಸಿ ನಂತರ ಅವುಗಳ ಸಂಖ್ಯಾತ್ಮಕ ಮೌಲ್ಯಗಳನ್ನು ಹೋಲಿಸುವ ಮೂಲಕ ಮಾಡಲಾಗುತ್ತದೆ. ಇದು ಮೂಲ ಡ್ಯುರೇಶನ್ ಆಬ್ಜೆಕ್ಟ್ಗಳಲ್ಲಿ ಬಳಸಲಾದ ಘಟಕಗಳನ್ನು ಲೆಕ್ಕಿಸದೆ ನಿಖರವಾದ ಹೋಲಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
const durationX = Temporal.Duration.from({ days: 1, hours: 12 }); // 1.5 days
const durationY = Temporal.Duration.from({ hours: 36 }); // 1.5 days
const durationZ = Temporal.Duration.from({ days: 2 }); // 2 days
console.log(Temporal.Duration.compare(durationX, durationY)); // 0 (equal)
console.log(Temporal.Duration.compare(durationX, durationZ)); // -1 (durationX is less than durationZ)
console.log(Temporal.Duration.compare(durationZ, durationY)); // 1 (durationZ is greater than durationY)
// Comparison with negative durations
const negDuration1 = Temporal.Duration.from({ hours: -5 });
const negDuration2 = Temporal.Duration.from({ hours: -10 });
console.log(Temporal.Duration.compare(negDuration1, negDuration2)); // 1 (e.g., -5 is greater than -10)
ಡ್ಯುರೇಶನ್ಗಳು ಮತ್ತು ದಿನಾಂಕಗಳು/ಸಮಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು
Temporal.Duration ಸಮಯದ ಪ್ರಮಾಣವನ್ನು ಪ್ರತಿನಿಧಿಸಿದರೂ, ಅದರ ನಿಜವಾದ ಉಪಯುಕ್ತತೆಯನ್ನು Temporal.PlainDate, Temporal.PlainDateTime, Temporal.ZonedDateTime, ಮತ್ತು Temporal.Instant ನಂತಹ ನಿರ್ದಿಷ್ಟ ಸಮಯದ ಬಿಂದುಗಳು ಅಥವಾ ದಿನಾಂಕ/ಸಮಯ ಆಬ್ಜೆಕ್ಟ್ಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಿದಾಗ ಹೆಚ್ಚಾಗಿ ಅರಿತುಕೊಳ್ಳಲಾಗುತ್ತದೆ. ಈ ಆಬ್ಜೆಕ್ಟ್ಗಳ ಮೇಲಿನ ಅಂಕಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳು ಅವಧಿಯ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಪರೋಕ್ಷವಾಗಿ ಬಳಸುತ್ತವೆ.
ದಿನಾಂಕಗಳು/ಸಮಯಗಳಿಂದ ಡ್ಯುರೇಶನ್ಗಳನ್ನು ಸೇರಿಸುವುದು/ಕಳೆಯುವುದು
ದಿನಾಂಕ/ಸಮಯ ಆಬ್ಜೆಕ್ಟ್ಗಳ ಮೇಲಿನ add() ಮತ್ತು subtract() ನಂತಹ ಮೆಥಡ್ಗಳು Duration ಅನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತವೆ. ಇಲ್ಲಿ ಕ್ಯಾಲೆಂಡರ್ ಅಂಕಗಣಿತದ ಸಂಕೀರ್ಣತೆಗಳನ್ನು (ಅಧಿಕ ವರ್ಷಗಳು, ವಿಭಿನ್ನ ದಿನಗಳಿರುವ ತಿಂಗಳುಗಳು) ಟೆಂಪೊರಲ್ ನಿರ್ವಹಿಸುತ್ತದೆ.
// Example using Temporal.PlainDate (requires polyfill or native support)
// Assuming you have a Temporal polyfill or native support in your environment.
// Let's imagine today is July 15, 2024
const today = Temporal.PlainDate.from({ year: 2024, month: 7, day: 15 });
const durationToAdd = Temporal.Duration.from({ years: 1, months: 3, days: 15 });
const futureDate = today.add(durationToAdd);
console.log(futureDate);
// Temporal.PlainDate { year: 2025, month: 11, day: 1 }
// Global example: Calculating a future date considering different month lengths
const londonDate = Temporal.PlainDate.from({ year: 2024, month: 1, day: 31 }); // January 31st
const durationForNextMonth = Temporal.Duration.from({ months: 1 });
const nextMonthDate = londonDate.add(durationForNextMonth);
console.log(nextMonthDate);
// Temporal.PlainDate { year: 2024, month: 2, day: 29 } // Correctly handles leap year and end of month.
const newYorkDate = Temporal.ZonedDateTime.from({
timeZone: 'America/New_York',
year: 2024,
month: 10,
day: 28,
hour: 10,
minute: 0,
second: 0
});
const travelDuration = Temporal.Duration.from({ hours: 8 }); // An 8-hour flight
// Note: When adding durations to ZonedDateTime, it's crucial to consider the time zone.
// The result will be in the same time zone unless specified otherwise.
const arrivalTimeNY = newYorkDate.add(travelDuration);
console.log(arrivalTimeNY);
// Temporal.ZonedDateTime { year: 2024, month: 10, day: 28, hour: 18, minute: 0, second: 0, ... }
// If you want to calculate arrival time in a DIFFERENT time zone, you'd typically:
// 1. Add duration to the departure ZonedDateTime.
// 2. Convert the resulting ZonedDateTime to the destination time zone.
const tokyoTimeZone = 'Asia/Tokyo';
const arrivalTimeTokyo = arrivalTimeNY.withTimeZone(tokyoTimeZone);
console.log(arrivalTimeTokyo);
// Temporal.ZonedDateTime { year: 2024, month: 10, day: 29, hour: 7, minute: 0, second: 0, ... } (Note the date and time change due to time zone)
ದಿನಾಂಕಗಳು/ಸಮಯಗಳ ನಡುವಿನ ಅವಧಿಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು
ದಿನಾಂಕ/ಸಮಯ ಆಬ್ಜೆಕ್ಟ್ಗಳ ಮೇಲಿನ until() ಮತ್ತು since() ಮೆಥಡ್ಗಳು Temporal.Duration ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತವೆ. ಎರಡು ಬಿಂದುಗಳ ನಡುವೆ ಕಳೆದ ಸಮಯವನ್ನು ಈ ರೀತಿ ಅಳೆಯಲಾಗುತ್ತದೆ.
const startDate = Temporal.PlainDate.from({ year: 2023, month: 1, day: 1 });
const endDate = Temporal.PlainDate.from({ year: 2024, month: 3, day: 15 });
const elapsedDuration = startDate.until(endDate);
console.log(elapsedDuration);
// Temporal.Duration { years: 1, months: 2, days: 14, ... }
// Global example: Calculating contract length difference
const contractStart = Temporal.ZonedDateTime.from({
timeZone: 'UTC',
year: 2022,
month: 5,
day: 10,
hour: 9,
minute: 0
});
const contractEnd = Temporal.ZonedDateTime.from({
timeZone: 'UTC',
year: 2025,
month: 8,
day: 20,
hour: 17,
minute: 30
});
const contractLength = contractStart.until(contractEnd);
console.log(contractLength);
// Temporal.Duration { years: 3, months: 3, days: 10, hours: 8, minutes: 30, ... }
// When using until/since with ZonedDateTime, the result can be complex due to time zones and DST.
// Temporal handles this by giving you a duration that may not 'round trip' perfectly if you just add it back without considering the time zone.
ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಮತ್ತು ಜಾಗತಿಕ ಪರಿಗಣನೆಗಳು
ಟೆಂಪೊರಲ್ ಡ್ಯುರೇಶನ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ವಿಶೇಷವಾಗಿ ಜಾಗತಿಕ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ಅಂಶಗಳನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ:
-
ಬದಲಾಯಿಸಲಾಗದಿರುವುದು ಪ್ರಮುಖವಾಗಿದೆ (Immutability is Key): ಯಾವಾಗಲೂ
Durationಆಬ್ಜೆಕ್ಟ್ಗಳನ್ನು ಬದಲಾಯಿಸಲಾಗದವು ಎಂದು ಪರಿಗಣಿಸಿ. ಯಾವುದೇ ಕಾರ್ಯಾಚರಣೆಯು ಹೊಸ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇದು ಅನಪೇಕ್ಷಿತ ಅಡ್ಡ ಪರಿಣಾಮಗಳನ್ನು ತಡೆಯುತ್ತದೆ. -
ಘಟಕಗಳ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ ಮತ್ತು ಕ್ಯಾಲೆಂಡರ್ ಅಂಕಗಣಿತವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ:
Durationಅಂಕಗಣಿತವು ಘಟಕಗಳ ಸರಳ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯನ್ನು ಮಾಡುತ್ತದೆ. ನೀವುDurationಅನ್ನು ದಿನಾಂಕ/ಸಮಯ ಆಬ್ಜೆಕ್ಟ್ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಿದಾಗ, ಟೆಂಪೊರಲ್ನ ಮೆಥಡ್ಗಳು (PlainDateಮೇಲಿನadd()ನಂತೆ) ಕ್ಯಾಲೆಂಡರ್-ಅರಿತ ಅಂಕಗಣಿತವನ್ನು ನಿರ್ವಹಿಸುತ್ತವೆ, ಇದು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದೆ ಮತ್ತು ತಿಂಗಳ ದಿನಗಳ ವ್ಯತ್ಯಾಸ, ಅಧಿಕ ವರ್ಷಗಳು ಇತ್ಯಾದಿಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. -
ಟೈಮ್ಝೋನ್ಗಳು ಅತ್ಯಂತ ಮುಖ್ಯ: ವಿಭಿನ್ನ ಪ್ರದೇಶಗಳಲ್ಲಿನ ಬಳಕೆದಾರರು ಅಥವಾ ಈವೆಂಟ್ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವ ಯಾವುದೇ ಅಪ್ಲಿಕೇಶನ್ಗೆ,
Temporal.ZonedDateTimeಅನ್ನು ಬಳಸುವುದು ಅತ್ಯಗತ್ಯ.Durationಆಬ್ಜೆಕ್ಟ್ ಸ್ವತಃ ಟೈಮ್ಝೋನ್-ಅಜ್ಞಾತವಾಗಿದೆ, ಆದರೆ ವಿಭಿನ್ನ ವಲಯಗಳಲ್ಲಿ ಕಳೆದ ಸಮಯವನ್ನು ಸರಿಯಾಗಿ ಪ್ರತಿನಿಧಿಸಲುZonedDateTimeನೊಂದಿಗೆ ಅದರ ಅನ್ವಯವನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ನಿರ್ವಹಿಸಬೇಕು. - ISO 8601 ನಿಮ್ಮ ಸ್ನೇಹಿತ: ಸಾಧ್ಯವಾದಾಗಲೆಲ್ಲಾ ಡ್ಯುರೇಶನ್ಗಳಿಗಾಗಿ ISO 8601 ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು ಬಳಸಿ. ಅವು ಪ್ರಮಾಣಿತ, ಅಸ್ಪಷ್ಟವಲ್ಲದ, ಮತ್ತು ಪಾರ್ಸ್ ಮಾಡಲು ಮತ್ತು ರಚಿಸಲು ಸುಲಭ, ಇದು ಸಿಸ್ಟಮ್ಗಳ ನಡುವಿನ ಡೇಟಾ ವಿನಿಮಯಕ್ಕೆ ಮತ್ತು ಅಂತರರಾಷ್ಟ್ರೀಯ ಸ್ಥಿರತೆಗೆ ಅವುಗಳನ್ನು ಆದರ್ಶವಾಗಿಸುತ್ತದೆ.
-
ಸೂಕ್ತವಾದ ರೌಂಡಿಂಗ್ ಅನ್ನು ಆಯ್ಕೆಮಾಡಿ:
round()ಮೆಥಡ್ ಶಕ್ತಿಯುತವಾಗಿದೆ ಆದರೆ ನಿಮ್ಮ ರೌಂಡಿಂಗ್ ಅಗತ್ಯಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಅಗತ್ಯವಿದೆ. ಹಣಕಾಸಿನ ಲೆಕ್ಕಾಚಾರಗಳಿಗೆ, ನಿರ್ದಿಷ್ಟ ರೌಂಡಿಂಗ್ ನಿಯಮಗಳು ಅನ್ವಯಿಸಬಹುದು. ಸಾಮಾನ್ಯ ಸಮಯ ಪ್ರದರ್ಶನಕ್ಕಾಗಿ,halfExpandಸಾಮಾನ್ಯವಾಗಿ ಸೂಕ್ತವಾಗಿದೆ. - ಬಳಕೆದಾರರ ಅನುಭವವನ್ನು ಪರಿಗಣಿಸಿ: ಬಳಕೆದಾರರಿಗೆ ಡ್ಯುರೇಶನ್ಗಳನ್ನು ಪ್ರದರ್ಶಿಸುವಾಗ, ಔಟ್ಪುಟ್ ಅನ್ನು ಸ್ಥಳೀಕರಿಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ಟೆಂಪೊರಲ್ ಕಚ್ಚಾ ಡ್ಯುರೇಶನ್ ಅನ್ನು ಒದಗಿಸಿದರೂ, 'P1Y2M' ಅನ್ನು '1 ವರ್ಷ ಮತ್ತು 2 ತಿಂಗಳುಗಳು' ಅಥವಾ '14 ತಿಂಗಳುಗಳು' ಎಂದು ಪ್ರಸ್ತುತಪಡಿಸುವುದು ಸಂದರ್ಭ ಮತ್ತು ಸ್ಥಳವನ್ನು ಅವಲಂಬಿಸಿ ಹೆಚ್ಚು ಬಳಕೆದಾರ ಸ್ನೇಹಿಯಾಗಿರಬಹುದು.
- ಮಾನದಂಡವನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ: ಟೆಂಪೊರಲ್ API ಒಂದು ಮಾನದಂಡವಾಗಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಇದು ವ್ಯಾಪಕವಾದ ಅಳವಡಿಕೆ ಮತ್ತು ಬ್ರೌಸರ್ ಬೆಂಬಲವನ್ನು ಗಳಿಸಿದಂತೆ, ಅದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗುವುದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲ ಮತ್ತು ಭವಿಷ್ಯಕ್ಕೆ ಸಿದ್ಧವಾಗಿಸುತ್ತದೆ.
ತೀರ್ಮಾನ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನ ಟೆಂಪೊರಲ್ API, ಅದರ Duration ಆಬ್ಜೆಕ್ಟ್ನೊಂದಿಗೆ, ಸಮಯ-ಆಧಾರಿತ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ನಿರ್ವಹಿಸುವಲ್ಲಿ ಒಂದು ಮಹತ್ವದ ಪ್ರಗತಿಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಡ್ಯುರೇಶನ್ ಅಂಕಗಣಿತಕ್ಕಾಗಿ ದೃಢವಾದ, ಬದಲಾಯಿಸಲಾಗದ ಮತ್ತು ಗಣಿತೀಯವಾಗಿ ಸರಿಯಾದ ಚೌಕಟ್ಟನ್ನು ಒದಗಿಸುವ ಮೂಲಕ, ಇದು ಡೆವಲಪರ್ಗಳಿಗೆ ಹೆಚ್ಚು ವಿಶ್ವಾಸಾರ್ಹ ಮತ್ತು ನಿಖರವಾದ ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಅಧಿಕಾರ ನೀಡುತ್ತದೆ. ನೀವು ಅಂತರರಾಷ್ಟ್ರೀಯ ಯೋಜನೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತಿರಲಿ, ಜಾಗತಿಕ ವೇಳಾಪಟ್ಟಿ ಪರಿಕರಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತಿರಲಿ, ಅಥವಾ ಕೇವಲ ನಿಖರವಾದ ಸಮಯದ ಅಂತರದ ಲೆಕ್ಕಾಚಾರಗಳ ಅಗತ್ಯವಿದ್ದರೂ, ಟೆಂಪೊರಲ್ ಡ್ಯುರೇಶನ್ ಅಂಕಗಣಿತದಲ್ಲಿ ಪ್ರಾವೀಣ್ಯತೆ ಪಡೆಯುವುದು ಯಾವುದೇ ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್ಗೆ ಅಮೂಲ್ಯವಾದ ಕೌಶಲ್ಯವಾಗಿರುತ್ತದೆ.
ಜಗತ್ತು ಹೆಚ್ಚೆಚ್ಚು ಪರಸ್ಪರ ಸಂಪರ್ಕಗೊಳ್ಳುತ್ತಿದ್ದಂತೆ, ವಿಭಿನ್ನ ಪ್ರದೇಶಗಳು ಮತ್ತು ಸಂದರ್ಭಗಳಲ್ಲಿ ಸಮಯದ ಅಂತರಗಳನ್ನು ನಿಖರವಾಗಿ ಮತ್ತು ಅರ್ಥಗರ್ಭಿತವಾಗಿ ನಿರ್ವಹಿಸುವ ಸಾಮರ್ಥ್ಯವು ಇನ್ನು ಮುಂದೆ ಐಷಾರಾಮಿಯಾಗಿಲ್ಲ, ಆದರೆ ಒಂದು ಅವಶ್ಯಕತೆಯಾಗಿದೆ. Temporal.Duration ಆಬ್ಜೆಕ್ಟ್ ಈ ಸಾಮರ್ಥ್ಯವನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಲು ನಿಮ್ಮ ಕೀಲಿಯಾಗಿದೆ, ಇದು ಹೆಚ್ಚು ಅತ್ಯಾಧುನಿಕ ಮತ್ತು ಜಾಗತಿಕವಾಗಿ ಅರಿವುಳ್ಳ ಅಪ್ಲಿಕೇಶನ್ಗಳಿಗೆ ದಾರಿ ಮಾಡಿಕೊಡುತ್ತದೆ.